吴师兄学算法

# LeetCode 142、环形链表II

# 一、题目描述

给定一个链表，返回链表开始入环的第一个节点。

如果链表无环，则返回 null。为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。

如果 pos 是 -1，则在该链表中没有环。

注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

说明：不允许修改给定的链表。

# 二、题目解析

1、通过快慢指针的方式，在环中寻找它们的第一次相遇的节点位置

2、当快慢指针相遇的时候：

img

x 代表从头节点到环形入口节点的节点数（不包含头节点）

y 代表从环形入口到第一次相遇节点的节点数（不包含环形入口节点）

z 代表从第一次相遇节点到环形入口的节点数（不包含第一次相遇节点）

此时，快指针走了 x + y + n (y + z)，其中，x + y 表示快指针第一次到达相遇节点，n 代表快指针在环里面绕了多少圈。

而慢指针走了 x + y 步。

那么就出现了一个等式 x + y = [x + y + n (y + z)] / 2，即x = n（y + z）- y。

n（y + z）- y 代表的含义是一个指针从相遇节点开始出发，走了 n 圈之后回到原来的出发位置，往后退 y 步。

由于 x 代表从头节点到环形入口节点的节点数，并且x = n（y + z）- y，所以n（y + z）- y 代表的含义就是一个指针从相遇节点开始出发，走了 n 圈之后回到原来的出发位置，往后退 y 步来到了环的入口位置。

那么，我们就可以设置两个指针，一个从链表的头节点开始出发，一个指针从相遇节点开始出发，当它们相遇的时候，代表着环的入口节点找到了。

补充：

  • 1、当 slow = 1 ， fast = 2 ，为什么 fast 和 slow 一定会相遇？
  • 2、当 slow = 1 ， fast = 2 ，fast 和 slow 相遇时，slow 指针是否绕环超过一圈？
  • 3、slow 和 fast 的移动步数有什么规则？
  • 4、能否设置为 slow 每次移动 1 步，fast 每次移动 3、4、5...步？
  • 5、为什么设置 slow = 1 ， fast = 2 ？
  • 6、为什么得出相反的结论？

为了方便大家理解与表达，所以回答尽可能的采取口语化的表达方式，面试的时候你直接拿去用就行。

# 1、当 slow = 1 ， fast = 2 ，为什么 fast 和 slow 一定会相遇？

首先，我们从现实角度去思考。

一个 400 米的圆形跑道上，有跑的慢的人、有跑的快的人，只要给予一定的时间，快的肯定会追上慢的，触发相遇。

环形链表在这个的基础上增加了一条限制：跑道并非连续，而是有一个个的节点组成的。

需要注意，如果两者没有在节点相遇，而是在节点与节点之间的位置相遇，那并非相遇只是相交。

1、假设，fast 在 slow 后方一个节点的位置，那么它们都跳一次之后，fast 和 slow 相遇了。

2、假设，fast 在 slow 后方两个节点的位置，那么它们都跳一次之后，fast 和 slow 的距离缩短为 1，变成了上述假设 1 的问题，可以相遇。

3、假设，fast 在 slow 后方 N 个节点的位置，那么它们都跳一次之后，fast 和 slow 的距离缩短为 N - 1，每条一次，都可以缩短一个单位，不断缩短，最终变成上述的假设 1。

所以，fast 和 slow 一定会相遇。

# 2、当 slow = 1 ， fast = 2 ，fast 和 slow 相遇时，slow 指针是否绕环超过一圈？

从 slow 进入环之后开始统计，fast 与 slow 相距最远的距离是 fast 在 slow 前方一个节点的位置。

img

此时，假设一下，fast 与 slow 同时在节点 2 开始出发，相当于两者相距一个环的距离。

img

当 slow 跑完一圈来到起始位置节点 2 时，由于 fast 速度是 slow 的两倍，那么 fast 必然跑了两圈也来到起始位置节点 2 ，两者相遇。

而此时，fast 在 slow 的前方位置，意味着两者的距离是小于一个完整的环的节点数的，说明 fast 可以更快的追上 slow。

既然 fast 与 slow 相距一个环的距离相遇时，slow 才能跑一圈，那么相距更短的距离，slow 没有跑完一圈，两者相遇了。

# 3、slow 和 fast 的移动步数有什么规则？

只需要两者的步数不一致就行。

# 4、能否设置为 slow 每次移动 1 步，fast 每次移动 3、4、5...步？

先说答案：可以！

首先，只要快慢两个指针都进入环中，两者有速度差，快指针就一定能够追上慢指针。

追上可以分为两种情况：

1、恰好追上，即快慢指针在某个位置相遇了 2、快指针超过了慢指针，快指针跑到了慢指针的前面了

所以，我们需要分析的就是第二种情况：跑到前面之后能否多跑几圈之后刚好相遇。

假设环的周长为整数 L，slow 每次走 a 步，fast 每次走 b 步，a ≠ b。

img

相遇时，两者都走了 t 次。

1、slow 走过的路程：x + y + n(y+z), n 代表 slow 绕了 n 圈 2、fast 走过的路程：x + y + m(y+z)，m 代表 fast饶了 m 圈 3、m > n

对于 slow ：x + y + n(y+z) = a * t

对于 fast ：x + y + m(y+z) = b * t

两者一相减：

“

(m - n)( y + z ) = ( b - a ) * t

”

y + z 代表一圈的节点数，y + z = L

“

(m - n)L = ( b - a ) * t

”

b - a 为一个正整数，假设为 c 。

**t = (**m - n)L / c。

其中 L 为常量，m 与 n 都可以随便设置，因此 m - n 的值可以为 1、2、3、。。。，

无论 c 取任何的正整数值，始终可以找到 m 与 n，计算得到一个正整数 t 。

也就是说 c 可以为 1、2、3、4、5。。。

说明 slow 与 fast 的速度差可以为 1、2、3、4、5。。。

由此也证明了 slow 每次走 1 步，fast 每次走 2 步、3 步、4 步。。。都是可以相遇的。

甚至，slow 每次走 2 步，fast 每次 3 步、4 步。。。都是可以相遇的。

只要 a ≠ b，存在步数差。

# 5、为什么设置 slow = 1 ， fast = 2 ？

由于 **b - a = (**m - n)L / t。

说明速度差 b - a 越小，fast 和 slow 跑的圈数就越小，经历的节点数也就越少，

由此 b – a = 1 是一个最小的答案，即 fast 和 slow 相差一步最合理。

然后，再来看，slow 进环的时候，fast 已经在环里面了，当 slow 来到环入口的时候，代表 fast 已经快跑了一圈。

所以，fast 和 slow 相遇，m 至少为 1。

m 越小，fast 总共走的路程就越小，时间复杂度就越低。

所以，m = 1 时最低的时间复杂度。

所以，fast 跑的越慢，越能在环中少跑几圈等到还在外面直线跑的 slow。

由于 a ≠ b， b – a = 1 ，a = 1，所以 b = 2。

所以，设置 slow 为 1 ，fast 为 2 最合理！

# 6、为什么得出相反的结论？

关于 fast 与 slow 能否相遇的问题，我在网上看到这样的回答。

img

仔细看看，是不是很有道理，但得到的结论却和本文问题 4 得出的结论不符。

谁是对的呢？

我们顺着它的假设来模拟一下。

假设环的周长为偶数，也就是六个节点。

img

并且进入环后 slow = 1 ，fast = 3，slow 与 fast 的距离为奇数。

img

模拟一下，fast 始终会出现在节点 4 和节点 1 这两个位置，当 slow 重新来到节点 1 的时候，fast 又来到了节点 4，如此反复，两者无法相遇。

这个结论是对的？？！！

这种假设根本就不会成立！

即进入环后 slow = 1 ，fast = 3，slow 与 fast 的距离为奇数这种假设无法成立。

在进入环之前，slow 和 fast 有一段公共的直线路需要走。

假设这条直线的长度为 m。

那么 slow 需要跳 m 次才能来到环入口位置节点 1 ，fast 需要跳 m/3 次才能第一次来到环入口位置节点 1，环的节点数是 6 个，fast 跑 2 次可以跑完一圈，假设跑了 n 圈，那么就跑了 2n 次，那么再跑一次就来到了节点 4 。

于是有了等式：m = m / 3 + 2n + 1。

计算一下得 n = ( 2m / 3 - 1 ) / 2。

由于 2m 为偶数，根据数学知识一个能被 3 整除的偶数除以 3 仍为偶数，于是 2m / 3 为偶数，2m / 3 - 1 为奇数， ( 2m / 3 - 1 ) / 2 无法是整数。

所以，找不到这样一个整数 m 和整数 n，使得上面的假设成立。

假设不成立，结论也不成立！

# 三、参考代码

# 1、Java 代码

// 登录 AlgoMooc 官网获取更多算法图解
// https://www.algomooc.com
// 作者：程序员吴师兄
// 代码有看不懂的地方一定要私聊咨询吴师兄呀
// 环形链表 II （ LeetCode 142 ） : https://leetcode-cn.com/problems/linked-list-cycle-ii
public class Solution {
    public ListNode detectCycle(ListNode head) {
        
        // 1、通过快慢指针的方式，在环中寻找它们的第一次相遇的节点位置

        // 2、定义一个慢指针，每次只会向前移动 1 步
        ListNode slow = head;
        // 3、定义一个快指针，每次只会向前移动 2 步
        ListNode fast = head;

        // 4、如果链表有环，那么无论怎么移动，fast 指向的节点都是有值的
        while (fast != null && fast.next != null) {
            // 慢指针每次只会向前移动 1 步
            slow = slow.next;
            // 快指针每次只会向前移动 2 步
            fast = fast.next.next;

            // 快慢指针相遇，说明有环
            // x 代表从头节点到环形入口节点的节点数（不包含头节点）
            // y 代表从环形入口到第一次相遇节点的节点数（不包含环形入口节点）
            // z 代表从第一次相遇节点到环形入口的节点数（不包含第一次相遇节点）
            // y + z 代表环的节点总数
            // 此时，快指针走了 x + y + n (y + z)
            // 其中，x + y 表示快指针第一次到达相遇节点，n 代表快指针在环里面绕了多少圈
            // 此时，慢指针走了 x + y 步

            // 由于快指针每次走 2 步，所以快慢指针第一次相遇的时候出现一个等式
            // x + y = [x + y + n (y + z)] / 2
            // 即 2 * (x + y) = x + y + n (y + z)
            // 即 x + y = n（y + z）
            // 即 x = n（y + z）- y
            // 我们的目的就是去求 x
            
            // 定义两个指针，一个指向相遇节点，定义为 b，一个指向链表头节点，定义为 a

            // b 在环中绕圈圈，走了 n（y + z）步会回到原处，即回到相遇节点处
            // 由于 y 代表从环形入口到第一次相遇节点的节点数（不包含环形入口节点）
            // 所以 n（y + z） - y 时，b 到达了环形入口节点位置

            // 由于 x 代表从头节点到环形入口节点的节点数（不包含头节点）
            // 所以 a 走了 x 步时，a 到达了环形入口节点位置

            // 当 x = n（y + z）- y 时，找到了环形入口节点位置

            // 5、开始寻找环入口
            if (slow == fast) {

                // 定义两个指针，一个指向相遇节点，定义为 b，一个指向链表头节点，定义为 a
                // 一个指向相遇节点，定义为 b
                ListNode b = fast;

                // 一个指向链表头节点，定义为 a
                ListNode a = head;

                // 让 a 、b 两个指针向前移动，每次移动一步，直到相遇位置
                // 由于有环，必然相遇
                // 当 b 走了 n（y + z） - y 时，b 到达了环形入口节点位置
                // 当 a 走了 x 步时，a 到达了环形入口节点位置
                // a 与 b 相遇
                while (a != b) {
                    // a 指针每次只会向前移动 1 步
                    a = a.next;
                    // b 指针每次只会向前移动 1 步
                    b = b.next;
                }

                // 6、返回 a 和 b 相遇的节点位置就是环形入口节点位置
                return a;
            }
        }

        // 没有环，返回 null
        return null;
    }
}

# **2、**C++ 代码

// 登录 AlgoMooc 官网获取更多算法图解
// https://www.algomooc.com
// 作者：程序员吴师兄
// 代码有看不懂的地方一定要私聊咨询吴师兄呀
// 环形链表 II （ LeetCode 142 ） : https://leetcode-cn.com/problems/linked-list-cycle-ii
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        // 1、通过快慢指针的方式，在环中寻找它们的第一次相遇的节点位置

        // 2、定义一个慢指针，每次只会向前移动 1 步
        ListNode *slow = head;
        // 3、定义一个快指针，每次只会向前移动 2 步
        ListNode *fast = head;

        // 4、如果链表有环，那么无论怎么移动，fast 指向的节点都是有值的
        while (fast != NULL && fast->next != NULL) {
            // 慢指针每次只会向前移动 1 步
            slow = slow->next;
            // 快指针每次只会向前移动 2 步
            fast = fast->next->next;

            // 快慢指针相遇，说明有环
            // x 代表从头节点到环形入口节点的节点数（不包含头节点）
            // y 代表从环形入口到第一次相遇节点的节点数（不包含环形入口节点）
            // z 代表从第一次相遇节点到环形入口的节点数（不包含第一次相遇节点）
            // y + z 代表环的节点总数
            // 此时，快指针走了 x + y + n (y + z)
            // 其中，x + y 表示快指针第一次到达相遇节点，n 代表快指针在环里面绕了多少圈
            // 此时，慢指针走了 x + y 步

            // 由于快指针每次走 2 步，所以快慢指针第一次相遇的时候出现一个等式
            // x + y = [x + y + n (y + z)] / 2
            // 即 2 * (x + y) = x + y + n (y + z)
            // 即 x + y = n（y + z）
            // 即 x = n（y + z）- y
            // 我们的目的就是去求 x
            
            // 定义两个指针，一个指向相遇节点，定义为 b，一个指向链表头节点，定义为 a

            // b 在环中绕圈圈，走了 n（y + z）步会回到原处，即回到相遇节点处
            // 由于 y 代表从环形入口到第一次相遇节点的节点数（不包含环形入口节点）
            // 所以 n（y + z） - y 时，b 到达了环形入口节点位置

            // 由于 x 代表从头节点到环形入口节点的节点数（不包含头节点）
            // 所以 a 走了 x 步时，a 到达了环形入口节点位置

            // 当 x = n（y + z）- y 时，找到了环形入口节点位置

            // 5、开始寻找环入口
            if (slow == fast) {

                // 定义两个指针，一个指向相遇节点，定义为 b，一个指向链表头节点，定义为 a
                // 一个指向相遇节点，定义为 b
                ListNode *b = fast;

                // 一个指向链表头节点，定义为 a
                ListNode *a = head;

                // 让 a 、b 两个指针向前移动，每次移动一步，直到相遇位置
                // 由于有环，必然相遇
                // 当 b 走了 n（y + z） - y 时，b 到达了环形入口节点位置
                // 当 a 走了 x 步时，a 到达了环形入口节点位置
                // a 与 b 相遇
                while (a != b) {
                    // a 指针每次只会向前移动 1 步
                    a = a->next;
                    // b 指针每次只会向前移动 1 步
                    b = b->next;
                }

                // 6、返回 a 和 b 相遇的节点位置就是环形入口节点位置
                return a;
            }
        }

        // 没有环，返回 NULL
        return NULL;
    }
};

# 3、Python 代码

# 登录 AlgoMooc 官网获取更多算法图解
# https://www.algomooc.com
# 作者：程序员吴师兄
# 代码有看不懂的地方一定要私聊咨询吴师兄呀
# 环形链表 II （ LeetCode 142 ） : https://leetcode-cn.com/problems/linked-list-cycle-ii
class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        # 1、通过快慢指针的方式，在环中寻找它们的第一次相遇的节点位置

        # 2、定义一个慢指针，每次只会向前移动 1 步
        slow = head
        # 3、定义一个快指针，每次只会向前移动 2 步
        fast = head

        # 4、如果链表有环，那么无论怎么移动，fast 指向的节点都是有值的
        while fast != None and fast.next != None :
            # 慢指针每次只会向前移动 1 步
            slow = slow.next
            # 快指针每次只会向前移动 2 步
            fast = fast.next.next

            # 快慢指针相遇，说明有环
            # x 代表从头节点到环形入口节点的节点数（不包含头节点）
            # y 代表从环形入口到第一次相遇节点的节点数（不包含环形入口节点）
            # z 代表从第一次相遇节点到环形入口的节点数（不包含第一次相遇节点）
            # y + z 代表环的节点总数
            # 此时，快指针走了 x + y + n y + z)
            # 其中，x + y 表示快指针第一次到达相遇节点，n 代表快指针在环里面绕了多少圈
            # 此时，慢指针走了 x + y 步

            # 由于快指针每次走 2 步，所以快慢指针第一次相遇的时候出现一个等式
            # x + y = [x + y + n y + z)] / 2
            # 即 2 * x + y) = x + y + n y + z)
            # 即 x + y = n（y + z）
            # 即 x = n（y + z）- y
            # 我们的目的就是去求 x
            
            # 定义两个指针，一个指向相遇节点，定义为 b，一个指向链表头节点，定义为 a

            # b 在环中绕圈圈，走了 n（y + z）步会回到原处，即回到相遇节点处
            # 由于 y 代表从环形入口到第一次相遇节点的节点数（不包含环形入口节点）
            # 所以 n（y + z） - y 时，b 到达了环形入口节点位置

            # 由于 x 代表从头节点到环形入口节点的节点数（不包含头节点）
            # 所以 a 走了 x 步时，a 到达了环形入口节点位置

            # 当 x = n（y + z）- y 时，找到了环形入口节点位置

            # 5、开始寻找环入口
            if slow == fast :

                # 定义两个指针，一个指向相遇节点，定义为 b，一个指向链表头节点，定义为 a
                # 一个指向相遇节点，定义为 b
                b = fast

                # 一个指向链表头节点，定义为 a
                a = head

                # 让 a 、b 两个指针向前移动，每次移动一步，直到相遇位置
                # 由于有环，必然相遇
                # 当 b 走了 n（y + z） - y 时，b 到达了环形入口节点位置
                # 当 a 走了 x 步时，a 到达了环形入口节点位置
                # a 与 b 相遇
                while a != b :
                    # a 指针每次只会向前移动 1 步
                    a = a.next
                    # b 指针每次只会向前移动 1 步
                    b = b.next
                

                # 6、返回 a 和 b 相遇的节点位置就是环形入口节点位置
                return a
            
        # 没有环，返回 None
        return None

# 四、复杂度分析

时间复杂度：O(N)，其中 NN 为链表中节点的数目。在最初判断快慢指针是否相遇时，slow 指针走过的距离不会超过链表的总长度；随后寻找入环点时，走过的距离也不会超过链表的总长度。因此，总的执行时间为 O(N)+O(N)=O(N)。

空间复杂度：O(1)。

← LeetCode 11、盛水最多的容器 →